// utils/cloud.js
// 微信云数据库服务工具

// 数据库集合名称
const COLLECTIONS = {
  USERS: 'users',
  FAMILIES: 'families',
  DISHES: 'dishes',
  ORDERS: 'orders',
  CARTS: 'carts',
  FAMILY_ACTIVITIES: 'family_activities', // 新增家庭活动集合
  BACKGROUNDS: 'backgrounds' // 新增背景管理集合
}

// 获取数据库实例的函数
function getDB() {
  if (!wx.cloud) {
    throw new Error('微信云开发未初始化')
  }
  return wx.cloud.database()
}

// 用户相关操作
const userService = {
  // 创建用户
  async createUser(userData) {
    try {
      const db = getDB()
      
      // 注意：不需要手动设置 _openid，微信云开发会自动生成
      // _openid 字段会在用户首次访问云数据库时自动创建
      console.log('创建用户，数据:', userData)
      
      const result = await db.collection(COLLECTIONS.USERS).add({
        data: {
          ...userData,
          createTime: db.serverDate(),
          updateTime: db.serverDate()
        }
      })
      
      console.log('用户创建成功，结果:', result)
      return { success: true, data: result }
    } catch (error) {
      console.error('创建用户失败:', error)
      return { success: false, error }
    }
  },

  // 根据openid查询用户
  async getUserByOpenid(openid) {
    try {
      const db = getDB()
      console.log('查询用户，使用_openid:', openid)
      
      // 使用 _openid 字段查询，这是微信云开发自动生成的字段
      const result = await db.collection(COLLECTIONS.USERS)
        .where({ _openid: openid })
        .get()
      
      console.log('查询结果:', result)
      
      if (result.data && result.data.length > 0) {
        console.log('找到用户:', result.data[0])
        return { success: true, data: result.data[0] }
      } else {
        console.log('未找到用户')
        return { success: true, data: null }
      }
    } catch (error) {
      console.error('查询用户失败:', error)
      return { success: false, error }
    }
  },

  // 获取当前用户的_openid（用于调试和验证）
  async getCurrentUserOpenid() {
    try {
      const db = getDB()
      // 通过查询当前用户来获取_openid
      const result = await db.collection(COLLECTIONS.USERS)
        .where({ _openid: db.command.exists(true) })
        .limit(1)
        .get()
      
      if (result.data && result.data.length > 0) {
        return { success: true, data: result.data[0]._openid }
      } else {
        return { success: false, error: '未找到当前用户' }
      }
    } catch (error) {
      console.error('获取当前用户openid失败:', error)
      return { success: false, error }
    }
  },

  // 更新用户信息
  async updateUser(userId, updateData) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.USERS)
        .doc(userId)
        .update({
          data: {
            ...updateData,
            updateTime: db.serverDate()
          }
        })
      return { success: true, data: result }
    } catch (error) {
      console.error('更新用户失败:', error)
      return { success: false, error }
    }
  },

  // 删除用户
  async deleteUser(userId) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.USERS)
        .doc(userId)
        .remove()
      return { success: true, data: result }
    } catch (error) {
      console.error('删除用户失败:', error)
      return { success: false, error }
    }
  },

  // 获取家庭成员
  async getFamilyMembers(familyId) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.USERS)
        .where({ familyId: familyId })
        .orderBy('createTime', 'desc')
        .limit(20)
        .get()
      return { success: true, data: result.data }
    } catch (error) {
      console.error('获取家庭成员失败:', error)
      return { success: false, error }
    }
  },

  // 更新用户积分
  async updateUserPoints(userId, points, operation = 'add') {
    try {
      const db = getDB()
      let updateData = {}
      
      if (operation === 'add') {
        updateData = {
          points: db.command.inc(points)
        }
      } else if (operation === 'subtract') {
        updateData = {
          points: db.command.inc(-points)
        }
      } else if (operation === 'set') {
        updateData = {
          points: points
        }
      }
      
      const result = await db.collection(COLLECTIONS.USERS)
        .doc(userId)
        .update({
          data: {
            ...updateData,
            updateTime: db.serverDate()
          }
        })
      return { success: true, data: result }
    } catch (error) {
      console.error('更新用户积分失败:', error)
      return { success: false, error }
    }
  },

  // 获取用户积分
  async getUserPoints(userId) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.USERS)
        .doc(userId)
        .field({ points: true })
        .get()
      
      console.log('获取用户积分结果:', result)
      const points = result.data.points || 0
      console.log('用户积分:', points)
      
      return { success: true, data: points }
    } catch (error) {
      console.error('获取用户积分失败:', error)
      return { success: false, error }
    }
  },

  // 获取完整用户信息（用于调试）
  async getUserById(userId) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.USERS)
        .doc(userId)
        .get()
      
      console.log('获取完整用户信息结果:', result)
      return { success: true, data: result.data }
    } catch (error) {
      console.error('获取用户信息失败:', error)
      return { success: false, error }
    }
  },

  // 更新用户角色
  async updateUserRole(userId, newRole) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.USERS)
        .doc(userId)
        .update({
          data: {
            role: newRole,
            updateTime: db.serverDate()
          }
        })
      return { success: true, data: result }
    } catch (error) {
      console.error('更新用户角色失败:', error)
      return { success: false, error }
    }
  },

  // 添加用户到家庭
  async addUserToFamily(userId, familyId, userData) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.USERS)
        .doc(userId)
        .update({
          data: {
            familyId: familyId,
            ...userData,
            updateTime: db.serverDate()
          }
        })
      return { success: true, data: result }
    } catch (error) {
      console.error('添加用户到家庭失败:', error)
      return { success: false, error }
    }
  },

  // 从家庭中移除用户
  async removeUserFromFamily(userId) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.USERS)
        .doc(userId)
        .update({
          data: {
            familyId: null,
            updateTime: db.serverDate()
          }
        })
      return { success: true, data: result }
    } catch (error) {
      console.error('从家庭中移除用户失败:', error)
      return { success: false, error }
    }
  },

  // 更新用户状态
  async updateUserStatus(userId, status) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.USERS)
        .doc(userId)
        .update({
          data: {
            status: status,
            updateTime: db.serverDate()
          }
        })
      return { success: true, data: result }
    } catch (error) {
      console.error('更新用户状态失败:', error)
      return { success: false, error }
    }
  }
}

// 家庭相关操作
const familyService = {
  // 创建家庭
  async createFamily(familyData) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.FAMILIES).add({
        data: {
          ...familyData,
          createTime: db.serverDate(),
          updateTime: db.serverDate()
        }
      })
      return { success: true, data: result }
    } catch (error) {
      console.error('创建家庭失败:', error)
      return { success: false, error }
    }
  },

  // 根据邀请码查询家庭
  async getFamilyByInviteCode(inviteCode) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.FAMILIES)
        .where({ inviteCode: inviteCode })
        .get()
      return { success: true, data: result.data[0] || null }
    } catch (error) {
      console.error('查询家庭失败:', error)
      return { success: false, error }
    }
  },

  // 根据ID查询家庭
  async getFamilyById(familyId) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.FAMILIES)
        .doc(familyId)
        .get()
      return { success: true, data: result.data }
    } catch (error) {
      console.error('根据ID查询家庭失败:', error)
      return { success: false, error }
    }
  },

  // 更新家庭信息
  async updateFamily(familyId, updateData) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.FAMILIES)
        .doc(familyId)
        .update({
          data: {
            ...updateData,
            updateTime: db.serverDate()
          }
        })
      return { success: true, data: result }
    } catch (error) {
      console.error('更新家庭失败:', error)
      return { success: false, error }
    }
  }
}

// 服务相关操作
const dishService = {
  // 创建服务
  async createDish(dishData) {
    try {
      const db = getDB()
      
      // 过滤掉不允许的字段，只保留允许的字段
      const allowedFields = ['name', 'desc', 'description', 'category', 'price', 'available', 'image', 'familyId']
      const filteredData = {}
      
      Object.keys(dishData).forEach(key => {
        if (allowedFields.includes(key)) {
          filteredData[key] = dishData[key]
        }
      })
      
      // 添加系统字段
      const finalData = {
        ...filteredData,
        createTime: db.serverDate(),
        updateTime: db.serverDate(),
        createdAt: db.serverDate(),
        updatedAt: db.serverDate(),
        createdBy: 'chef'
      }
      
      console.log('过滤后的创建数据:', finalData)
      
      const result = await db.collection(COLLECTIONS.DISHES).add({
        data: finalData
      })
      return { success: true, data: result }
    } catch (error) {
      console.error('创建服务失败:', error)
      return { success: false, error }
    }
  },

  // 获取指定家庭的服务
  async getDishesByFamily(familyId) {
    try {
      const db = getDB()
      
      let allDishes = []
      let hasMore = true
      let skip = 0
      const batchSize = 20 // 每批查询20条记录
      
      // 分批查询所有服务
      while (hasMore) {
        const batchResult = await db.collection(COLLECTIONS.DISHES)
          .where({
            familyId: familyId
          })
          .orderBy('createTime', 'desc')
          .skip(skip)
          .limit(batchSize)
          .get()
        
        allDishes = allDishes.concat(batchResult.data)
        
        // 如果返回的数据少于batchSize，说明没有更多数据了
        if (batchResult.data.length < batchSize) {
          hasMore = false
        } else {
          skip += batchSize
        }
        
        // 安全检查，避免无限循环
        if (skip > 1000) {
          hasMore = false
        }
      }
      
      return { success: true, data: allDishes }
    } catch (error) {
      console.error('查询服务失败:', error)
      return { success: false, error }
    }
  },

  // 更新服务
  async updateDish(dishId, updateData) {
    try {
      const db = getDB()
      
      // 先查询服务信息，检查权限
      const dish = await db.collection(COLLECTIONS.DISHES).doc(dishId).get()
      if (!dish.data) {
        console.error('服务不存在:', dishId)
        return { success: false, error: '服务不存在' }
      }
      
      // 检查当前用户权限
      try {
        const { userInfo } = await wx.cloud.getCurrentUserInfo()
        console.log('当前用户信息:', userInfo)
        console.log('服务创建者:', dish.data._openid)
        
        // 检查是否是服务创建者或管理员
        if (userInfo && userInfo.openid && dish.data._openid) {
          if (userInfo.openid !== dish.data._openid) {
            console.error('权限不足：当前用户不是服务创建者')
            return { 
              success: false, 
              error: '权限不足，只能编辑自己创建的服务',
              code: 'PERMISSION_DENIED'
            }
          }
        }
      } catch (userError) {
        console.warn('获取用户信息失败，继续更新操作:', userError)
      }
      
      const allowedFields = ['name', 'desc', 'description', 'category', 'price', 'available', 'image', 'familyId']
      const filteredData = {}
      Object.keys(updateData).forEach(key => {
        if (allowedFields.includes(key)) {
          filteredData[key] = updateData[key]
        }
      })
      filteredData.updateTime = db.serverDate()
      console.log('过滤后的更新数据:', filteredData)
      
      const result = await db.collection(COLLECTIONS.DISHES)
        .doc(dishId)
        .update({
          data: filteredData
        })
      return { success: true, data: result }
    } catch (error) {
      console.error('更新服务失败:', error)
      return { success: false, error }
    }
  },

  // 删除服务
  async deleteDish(dishId) {
    try {
      console.log('开始删除服务，ID:', dishId)
      
      const db = getDB()
      
      // 先查询记录是否存在
      const dish = await db.collection(COLLECTIONS.DISHES).doc(dishId).get()
      if (!dish.data) {
        console.error('服务不存在:', dishId)
        return { success: false, error: '服务不存在' }
      }
      
      console.log('找到服务:', dish.data)
      
      // 检查当前用户权限
      try {
        const { userInfo } = await wx.cloud.getCurrentUserInfo()
        console.log('当前用户信息:', userInfo)
        console.log('服务创建者:', dish.data._openid)
        
        // 检查是否是服务创建者或管理员
        if (userInfo && userInfo.openid && dish.data._openid) {
          if (userInfo.openid !== dish.data._openid) {
            console.error('权限不足：当前用户不是服务创建者')
            return { 
              success: false, 
              error: '权限不足，只能删除自己创建的服务',
              code: 'PERMISSION_DENIED'
            }
          }
        }
      } catch (userError) {
        console.warn('获取用户信息失败，继续删除操作:', userError)
      }
      
      // 尝试删除
      const result = await db.collection(COLLECTIONS.DISHES)
        .doc(dishId)
        .remove()
      
      console.log('删除成功:', result)
      return { success: true, data: result }
    } catch (error) {
      console.error('删除服务失败:', error)
      console.error('错误详情:', {
        message: error.message,
        code: error.code,
        stack: error.stack
      })
      
      // 根据错误类型提供更友好的错误信息
      let errorMessage = '删除失败'
      if (error.message && error.message.includes('permission')) {
        errorMessage = '权限不足，无法删除该服务'
      } else if (error.message && error.message.includes('not exist')) {
        errorMessage = '服务不存在或已被删除'
      } else if (error.message && error.message.includes('network')) {
        errorMessage = '网络连接失败，请重试'
      }
      
      return { success: false, error: errorMessage, originalError: error }
    }
  },

  // 批量创建默认服务（本地不需要默认服务）
  async createDefaultDishes(familyId) {
    const defaultDishes = [] // 空数组，本地不需要默认服务

    try {
      const promises = defaultDishes.map(dish => this.createDish(dish))
      const results = await Promise.all(promises)
      return { success: true, data: results }
    } catch (error) {
      console.error('创建默认服务失败:', error)
      return { success: false, error }
    }
  }
}

// 订单相关操作
const orderService = {
  // 创建订单
  async createOrder(orderData) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.ORDERS).add({
        data: {
          ...orderData,
          status: 'pending', // pending: 待处理, cooking: 制作中, completed: 已完成, cancelled: 已取消, rejected: 已拒绝
          createTime: db.serverDate(),
          updateTime: db.serverDate()
        }
      })
      return { success: true, data: result }
    } catch (error) {
      console.error('创建订单失败:', error)
      return { success: false, error }
    }
  },

  // 获取用户的订单
  async getUserOrders(userId, familyId) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.ORDERS)
        .where({
          userId: userId,
          familyId: familyId
        })
        .orderBy('createTime', 'desc')
        .limit(50)
        .get()
      return { success: true, data: result.data }
    } catch (error) {
      console.error('查询订单失败:', error)
      return { success: false, error }
    }
  },

  // 获取家庭的所有订单（厨师可以看到所有家庭成员的订单）
  async getFamilyOrders(familyId) {
    try {
      const db = getDB()
      // 需要传入familyId来获取家庭的所有订单
      if (!familyId) {
        console.error('getFamilyOrders: 缺少familyId参数，无法获取家庭订单')
        return { success: false, error: '缺少familyId参数' }
      }
      
      // 根据familyId查询订单，获取家庭所有成员的订单
      const result = await db.collection(COLLECTIONS.ORDERS)
        .where({ familyId: familyId })
        .orderBy('createTime', 'desc')
        .limit(100)
        .get()
      
      console.log(`查询家庭 ${familyId} 的所有订单，共 ${result.data.length} 个`)
      return { success: true, data: result.data }
    } catch (error) {
      console.error('查询家庭订单失败:', error)
      return { success: false, error }
    }
  },

  // 更新订单状态
  async updateOrderStatus(orderId, status) {
    try {
      console.log(`云数据库开始更新订单状态: ${orderId} -> ${status}`)
      const db = getDB()
      
      // 先查询订单是否存在
      const orderDoc = await db.collection(COLLECTIONS.ORDERS).doc(orderId).get()
      console.log('查询到的订单文档:', orderDoc)
      
      if (!orderDoc.data) {
        console.error('订单不存在:', orderId)
        return { success: false, error: '订单不存在' }
      }
      
      const order = orderDoc.data
      const oldStatus = order.status
      
      console.log('订单存在，开始更新状态...')
      const result = await db.collection(COLLECTIONS.ORDERS)
        .doc(orderId)
        .update({
          data: {
            status: status,
            updateTime: db.serverDate()
          }
        })
      
      console.log('云数据库更新结果:', result)
      
      // 检查是否需要退还积分
      if (this.shouldRefundPoints(oldStatus, status)) {
        console.log('检测到需要退还积分，开始处理...')
        await this.refundOrderPoints(order)
      }
      
      return { success: true, data: result }
    } catch (error) {
      console.error('更新订单状态失败:', error)
      return { success: false, error }
    }
  },

  // 判断是否需要退还积分
  shouldRefundPoints(oldStatus, newStatus) {
    // 当订单从待确认或制作中状态变为已取消或已拒绝时，需要退还积分
    const shouldRefund = (
      (oldStatus === 'pending' || oldStatus === 'cooking') && 
      (newStatus === 'cancelled' || newStatus === 'rejected')
    )
    
    console.log(`积分退还判断: ${oldStatus} -> ${newStatus}, 需要退还: ${shouldRefund}`)
    return shouldRefund
  },

  // 退还订单积分
  async refundOrderPoints(order) {
    try {
      console.log('开始退还订单积分:', order)
      
      if (!order.userId || !order.totalAmount) {
        console.error('订单信息不完整，无法退还积分:', order)
        return { success: false, error: '订单信息不完整' }
      }
      
      // 直接调用数据库操作，避免循环引用
      const db = getDB()
      const result = await db.collection(COLLECTIONS.USERS)
        .doc(order.userId)
        .update({
          data: {
            points: db.command.inc(order.totalAmount),
            updateTime: db.serverDate()
          }
        })
      
      if (result.stats && result.stats.updated > 0) {
        console.log(`积分退还成功，用户 ${order.userId} 获得 ${order.totalAmount} 积分`)
        return { success: true, data: result }
      } else {
        console.error('积分退还失败: 数据库更新失败')
        return { success: false, error: '数据库更新失败' }
      }
    } catch (error) {
      console.error('退还订单积分时发生错误:', error)
      return { success: false, error }
    }
  },

  // 获取家庭订单统计（厨师可以看到所有家庭成员的订单统计）
  async getFamilyOrderStats(familyId) {
    try {
      const db = getDB()
      // 需要传入familyId来获取家庭的所有订单统计
      if (!familyId) {
        console.error('getFamilyOrderStats: 缺少familyId参数，无法获取家庭订单统计')
        return { success: false, error: '缺少familyId参数' }
      }
      
      console.log(`查询家庭 ${familyId} 的订单统计`)
      
      // 根据familyId查询订单，获取家庭所有成员的订单
      const result = await db.collection(COLLECTIONS.ORDERS)
        .where({ familyId: familyId })
        .get()
      
      const orders = result.data || []
      console.log(`家庭 ${familyId} 的订单数据:`, orders)
      
      const stats = {
        pending: orders.filter(order => order.status === 'pending').length,
        cooking: orders.filter(order => order.status === 'cooking').length,
        completed: orders.filter(order => order.status === 'completed').length,
        total: orders.length
      }
      
      console.log(`家庭 ${familyId} 的订单统计结果:`, stats)
      return { success: true, data: stats }
    } catch (error) {
      console.error('获取家庭订单统计失败:', error)
      return { success: false, error }
    }
  },

  // 获取所有订单（调试用）
  async getAllOrders() {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.ORDERS).get()
      console.log('云数据库中的所有订单:', result.data)
      return { success: true, data: result.data }
    } catch (error) {
      console.error('获取所有订单失败:', error)
      return { success: false, error }
    }
  },

  // 修复订单的家庭ID（用于修复历史数据）
  async fixOrderFamilyId(orderId, familyId) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.ORDERS)
        .doc(orderId)
        .update({
          data: {
            familyId: familyId,
            updateTime: db.serverDate()
          }
        })
      return { success: true, data: result }
    } catch (error) {
      console.error('修复订单家庭ID失败:', error)
      return { success: false, error }
    }
  }
}

// 家庭活动相关操作
const activityService = {
  // 创建家庭活动
  async createActivity(activityData) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.FAMILY_ACTIVITIES).add({
        data: {
          ...activityData,
          createTime: db.serverDate(),
          updateTime: db.serverDate()
        }
      })
      console.log('家庭活动创建成功:', result)
      return { success: true, data: result }
    } catch (error) {
      console.error('创建家庭活动失败:', error)
      return { success: false, error }
    }
  },

  // 获取家庭的所有活动
  async getFamilyActivities(familyId) {
    try {
      const db = getDB()
      let result;
      
      if (familyId) {
        // 如果指定了家庭ID，获取该家庭的活动
        result = await db.collection(COLLECTIONS.FAMILY_ACTIVITIES)
          .where({ familyId: familyId })
          .orderBy('createTime', 'desc')
          .limit(20)
          .get()
      } else {
        // 如果没有指定家庭ID，获取所有公开的家庭活动
        result = await db.collection(COLLECTIONS.FAMILY_ACTIVITIES)
          .orderBy('createTime', 'desc')
          .limit(20) // 限制数量避免数据过多
          .get()
      }
      
      return { success: true, data: result.data }
    } catch (error) {
      console.error('获取家庭活动失败:', error)
      return { success: false, error }
    }
  },

  // 更新家庭活动
  async updateActivity(activityId, updateData) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.FAMILY_ACTIVITIES)
        .doc(activityId)
        .update({
          data: {
            ...updateData,
            updateTime: db.serverDate()
          }
        })
      console.log('家庭活动更新成功:', result)
      return { success: true, data: result }
    } catch (error) {
      console.error('更新家庭活动失败:', error)
      return { success: false, error }
    }
  },

  // 删除家庭活动
  async deleteActivity(activityId) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.FAMILY_ACTIVITIES)
        .doc(activityId)
        .remove()
      console.log('家庭活动删除成功:', result)
      return { success: true, data: result }
    } catch (error) {
      console.error('删除家庭活动失败:', error)
      return { success: false, error }
    }
  }
}

// 购物车相关操作
const cartService = {
  // 添加到购物车
  async addToCart(cartData) {
    try {
      const db = getDB()
      // 检查是否已存在相同服务
      const existing = await db.collection(COLLECTIONS.CARTS)
        .where({
          userId: cartData.userId,
          familyId: cartData.familyId,
          dishId: cartData.dishId
        })
        .get()

      if (existing.data.length > 0) {
        // 更新数量
        const result = await db.collection(COLLECTIONS.CARTS)
          .doc(existing.data[0]._id)
          .update({
            data: {
              quantity: existing.data[0].quantity + cartData.quantity,
              updateTime: db.serverDate()
            }
          })
        return { success: true, data: result }
      } else {
        // 新增购物车项
        const result = await db.collection(COLLECTIONS.CARTS).add({
          data: {
            ...cartData,
            createTime: db.serverDate(),
            updateTime: db.serverDate()
          }
        })
        return { success: true, data: result }
      }
    } catch (error) {
      console.error('添加到购物车失败:', error)
      return { success: false, error }
    }
  },

  // 获取用户购物车
  async getUserCart(userId, familyId) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.CARTS)
        .where({
          userId: userId,
          familyId: familyId
        })
        .get()
      return { success: true, data: result.data }
    } catch (error) {
      console.error('查询购物车失败:', error)
      return { success: false, error }
    }
  },

  // 清空购物车
  async clearCart(userId, familyId) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.CARTS)
        .where({
          userId: userId,
          familyId: familyId
        })
        .remove()
      return { success: true, data: result }
    } catch (error) {
      console.error('清空购物车失败:', error)
      return { success: false, error }
    }
  }
}

// 背景管理服务
const backgroundService = {
  // 获取当前背景
  async getCurrentBackground() {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.BACKGROUNDS)
        .where({ isActive: true })
        .orderBy('updateTime', 'desc')
        .limit(1)
        .get()
      
      if (result.data && result.data.length > 0) {
        return { success: true, data: result.data[0] }
      } else {
        return { success: true, data: null }
      }
    } catch (error) {
      console.error('获取当前背景失败:', error)
      return { success: false, error }
    }
  },

  // 更新背景
  async updateBackground(backgroundData) {
    try {
      const db = getDB()
      
      // 如果设置了新背景，先将所有背景设为非活跃
      if (backgroundData.imageUrl) {
        await db.collection(COLLECTIONS.BACKGROUNDS)
          .where({ isActive: true })
          .update({
            data: { isActive: false }
          })
      }
      
      // 添加新背景记录
      const result = await db.collection(COLLECTIONS.BACKGROUNDS).add({
        data: {
          imageUrl: backgroundData.imageUrl,
          isActive: backgroundData.imageUrl ? true : false,
          updatedBy: backgroundData.updatedBy,
          updatedAt: backgroundData.updatedAt,
          createTime: db.serverDate(),
          updateTime: db.serverDate()
        }
      })
      
      console.log('背景更新成功:', result)
      return { success: true, data: result }
    } catch (error) {
      console.error('更新背景失败:', error)
      return { success: false, error }
    }
  },

  // 获取背景历史
  async getBackgroundHistory() {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.BACKGROUNDS)
        .orderBy('updateTime', 'desc')
        .limit(20)
        .get()
      
      return { success: true, data: result.data }
    } catch (error) {
      console.error('获取背景历史失败:', error)
      return { success: false, error }
    }
  },

  // 删除背景
  async deleteBackground(backgroundId) {
    try {
      const db = getDB()
      const result = await db.collection(COLLECTIONS.BACKGROUNDS)
        .doc(backgroundId)
        .remove()
      
      console.log('背景删除成功:', result)
      return { success: true, data: result }
    } catch (error) {
      console.error('删除背景失败:', error)
      return { success: false, error }
    }
  }
}

module.exports = {
  userService,
  familyService,
  dishService,
  orderService,
  cartService,
  activityService,
  backgroundService,
  COLLECTIONS
} 